home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Disk / moni / FileX-src.lha / FileX-src / rest.c < prev    next >
Encoding:
C/C++ Source or Header  |  2003-09-20  |  16.5 KB  |  788 lines
  1. #include "FileXStructs.h"
  2. #include "FileXStrings.h"
  3. #include "FileXARexx.h"
  4. #include "allprotos.h"
  5.  
  6. BOOL IsHexString(UBYTE *string)
  7. {
  8.     while(*string)
  9.     {
  10.         if(!isxdigit(*string))return(FALSE);
  11.         string++;
  12.     }
  13.     return(TRUE);
  14. }
  15.  
  16. /*
  17.  * BOOL MyGetString( char *String, char *WindowTitle, ULONG Max )
  18.  * 
  19.  * Öffnet ein Window mit Stringgadget zur Eingabe eines Strings.
  20.  */
  21.  
  22. BOOL MyGetString( char *String, char *WindowTitle, ULONG Max )
  23. {
  24.     enum {
  25.         GD_GETSTRING_STRING,
  26.         GD_GETSTRING_OK,
  27.         GD_GETSTRING_CANCEL
  28.     };
  29.  
  30.     static struct MyNewGadget GetStringNewGadgets[] =
  31.     {
  32.         STRING_KIND, 0, 0, 0, MSG_GADGET_STRING_STRING, 0, 8, 0, 0, 30,
  33.     
  34.         BUTTON_KIND, GP_LEFTBOTTOM, 0, 0, MSG_GADGET_OK, 0, 0, 0, 0, 0,
  35.         BUTTON_KIND, GP_RIGHTBOTTOM, 0, 0, MSG_GADGET_CANCEL, 0, 0, 0, 0, 0,
  36.         0
  37.     };
  38.  
  39.     static struct WindowData GetStringWD =
  40.     {
  41.         NULL,    NULL,    FALSE, NULL, NULL,
  42.         0,0,
  43.         &GetStringNewGadgets[ 0 ], 3
  44.     };
  45.  
  46.     BOOL Result = FALSE;
  47.  
  48.     long err;
  49.  
  50.     GetStringNewGadgets[ GD_GETSTRING_STRING ].Max = Max;
  51.     GetStringNewGadgets[ GD_GETSTRING_STRING ].CurrentValue = ( ULONG )String;
  52.  
  53.     if(( err = NewOpenAWindow( &GetStringWD, WindowTitle )))
  54.         MyRequest( MSG_INFO_GLOBAL_CANTOPENWINDOW, err );
  55.     else
  56.     {
  57.         int EndeFlag = FALSE;
  58.         ULONG signals;
  59.         struct IntuiMessage    *m, Msg;
  60.         struct Gadget *gad;
  61.  
  62.         ActivateGadget( GetStringWD.Gadgets[ GD_GETSTRING_STRING ], GetStringWD.Wnd, 0);
  63.     
  64.         while( EndeFlag == FALSE)
  65.         {
  66.             signals=Wait(1 << GetStringWD.Wnd->UserPort->mp_SigBit);
  67.     
  68.             if(signals&(1 << GetStringWD.Wnd->UserPort->mp_SigBit))
  69.                 while(m = GT_GetIMsg( GetStringWD.Wnd->UserPort))
  70.                 {
  71.                     CopyMem((char *)m, (char *)&Msg, (long)sizeof(struct IntuiMessage));
  72.     
  73.                     GT_ReplyIMsg(m);
  74.     
  75.                     KeySelect(GetStringWD.Gadgets, &Msg);
  76.     
  77.                     gad = (struct Gadget *) Msg.IAddress;
  78.     
  79.                     switch( Msg.Class )
  80.                     {
  81.                         case    IDCMP_REFRESHWINDOW:
  82.                             GT_BeginRefresh( GetStringWD.Wnd );
  83.                             GT_EndRefresh( GetStringWD.Wnd, TRUE );
  84.                             break;
  85.  
  86.                         case    IDCMP_VANILLAKEY:
  87.                             if( Msg.Code == 13)
  88.                             {
  89.                                 EndeFlag = TRUE;
  90.                                 Result = TRUE;
  91.                             }
  92.                             break;
  93.     
  94.                         case    IDCMP_CLOSEWINDOW:
  95.                             EndeFlag = TRUE;
  96.                             break;
  97.     
  98.                         case IDCMP_MOUSEMOVE:
  99.                             ((struct MyNewGadget *)gad->UserData)->CurrentValue = Msg.Code;
  100.                             break;
  101.     
  102.                         case    IDCMP_GADGETUP:
  103.                             switch(gad->GadgetID)
  104.                             {
  105.                                 case GD_GETSTRING_OK:
  106.                                 case GD_GETSTRING_STRING:
  107.                                     Result = TRUE;
  108.                                     EndeFlag = TRUE;
  109.                                     break;
  110.                                 case GD_GETSTRING_CANCEL:
  111.                                     EndeFlag = TRUE;
  112.                                     break;
  113.                             }
  114.                             break;
  115.                     }
  116.                 }
  117.         }
  118.  
  119.         if( Result )
  120.             strcpy( String, GetString( GetStringWD.Gadgets[ GD_GETSTRING_STRING ]));
  121.  
  122.         NewCloseAWindow( &GetStringWD );
  123.     }
  124.  
  125.     return( Result );
  126. }
  127.  
  128. /*
  129.  * BOOL GetWert( ULONG *Wert, char *WindowTitle, ULONG Min, ULONG Max )
  130.  * 
  131.  * Öffnet ein Window mit Slidergadget zum Einstellen eines Wertes.
  132.  */
  133.  
  134. BOOL GetWert( ULONG *Wert, char *WindowTitle, ULONG Min, ULONG Max )
  135. {
  136.     enum {
  137.         GD_GETWERT_NUMBER,
  138.         GD_GETWERT_OK,
  139.         GD_GETWERT_CANCEL
  140.     };
  141.  
  142.     static struct MyNewGadget GetWertNewGadgets[] =
  143.     {
  144.         SLIDER_KIND, 0, 0, 0, MSG_GADGET_NUMBER_NUMBER, 0, 8, 0, 8, 0,
  145.     
  146.         BUTTON_KIND, GP_LEFTBOTTOM, 0, 0, MSG_GADGET_OK, 0, 0, 0, 0, 0,
  147.         BUTTON_KIND, GP_RIGHTBOTTOM, 0, 0, MSG_GADGET_CANCEL, 0, 0, 0, 0, 0,
  148.         0
  149.     };
  150.  
  151.     static struct WindowData GetWertWD =
  152.     {
  153.         NULL,    NULL,    FALSE, NULL, NULL,
  154.         0,0,
  155.         &GetWertNewGadgets[ 0 ], 14
  156.     };
  157.  
  158.     BOOL Result = FALSE;
  159.  
  160.     long err;
  161.  
  162.     GetWertNewGadgets[ GD_GETWERT_NUMBER ].Max = Max;
  163.     GetWertNewGadgets[ GD_GETWERT_NUMBER ].Min = Min;
  164.     GetWertNewGadgets[ GD_GETWERT_NUMBER ].CurrentValue = *Wert;
  165.  
  166.     if(( err = NewOpenAWindow(    &GetWertWD, GetStr( WindowTitle ))))
  167.         MyRequest( MSG_INFO_GLOBAL_CANTOPENWINDOW, err );
  168.     else
  169.     {
  170.         int EndeFlag = FALSE;
  171.         ULONG signals;
  172.         struct IntuiMessage    *m, Msg;
  173.         struct Gadget *gad;
  174.  
  175.         while( EndeFlag == FALSE)
  176.         {
  177.             signals=Wait(1 << GetWertWD.Wnd->UserPort->mp_SigBit);
  178.     
  179.             if(signals&(1 << GetWertWD.Wnd->UserPort->mp_SigBit))
  180.                 while(m = GT_GetIMsg( GetWertWD.Wnd->UserPort))
  181.                 {
  182.                     CopyMem((char *)m, (char *)&Msg, (long)sizeof(struct IntuiMessage));
  183.     
  184.                     GT_ReplyIMsg(m);
  185.     
  186.                     KeySelect(GetWertWD.Gadgets, &Msg);
  187.     
  188.                     gad = (struct Gadget *) Msg.IAddress;
  189.     
  190.                     switch( Msg.Class )
  191.                     {
  192.                         case    IDCMP_REFRESHWINDOW:
  193.                             GT_BeginRefresh( GetWertWD.Wnd );
  194.                             GT_EndRefresh( GetWertWD.Wnd, TRUE );
  195.                             break;
  196.     
  197.                         case    IDCMP_VANILLAKEY:
  198.                             if( Msg.Code == 13)
  199.                             {
  200.                                 EndeFlag = TRUE;
  201.                                 Result = TRUE;
  202.                             }
  203.                             else
  204.                             if(( Msg.Code >= '0' ) && ( Msg.Code <= '9' ))
  205.                             {
  206.                                 if( Msg.Code == '0' )
  207.                                     Msg.Code += 10;
  208.                                 GT_SetGadgetAttrs( GetWertWD.Gadgets[ GD_GETWERT_NUMBER ] , GetWertWD.Wnd, NULL,
  209.                                     GTSL_Level, Msg.Code - '0',
  210.                                     TAG_DONE);
  211.                                 GetWertNewGadgets[ GD_GETWERT_NUMBER ].CurrentValue = Msg.Code - '0';
  212.                             }
  213.                             break;
  214.     
  215.                         case    IDCMP_CLOSEWINDOW:
  216.                             EndeFlag = TRUE;
  217.                             break;
  218.     
  219.                         case IDCMP_MOUSEMOVE:
  220.                             ((struct MyNewGadget *)gad->UserData)->CurrentValue = Msg.Code;
  221.                             break;
  222.     
  223.                         case    IDCMP_GADGETUP:
  224.                             switch(gad->GadgetID)
  225.                             {
  226.                                 case GD_GETWERT_OK:
  227.                                     Result = TRUE;
  228.                                     EndeFlag = TRUE;
  229.                                     break;
  230.                                 case GD_GETWERT_CANCEL:
  231.                                     EndeFlag = TRUE;
  232.                                     break;
  233.                             }
  234.                             break;
  235.                     }
  236.                 }
  237.         }
  238.  
  239.         if( Result )
  240.             *Wert = GetWertNewGadgets[ GD_GETWERT_NUMBER ].CurrentValue;
  241.  
  242.         NewCloseAWindow( &GetWertWD );
  243.     }
  244.  
  245.     return( Result );
  246. }
  247.  
  248. /*
  249.  * static ULONG MyMainFullRequest( char *Text, char *ButtonText, APTR Args )
  250.  * 
  251.  * Öffnet eine Informationsrequester.
  252.  */
  253.  
  254. static ULONG MyMainFullRequest( char *Text, char *ButtonText, APTR Args )
  255. {
  256.     if( UseAsl )
  257.     {
  258.         struct EasyStruct    Easy;
  259.         ULONG Result;
  260.         char *Gadgets;
  261.  
  262.         if( Gadgets = AllocVec( strlen( ButtonText ) + 1, MEMF_ANY ))
  263.         {
  264.                 /* Unterstriche aus dem Gadgettext entfernen */
  265.  
  266.             {
  267.                 char *gptr = Gadgets, *ptr = ButtonText;
  268.     
  269.                 while( *ptr )
  270.                 {
  271.                     if( *ptr != '_' ) *gptr++ = *ptr++;
  272.                     else ptr++;
  273.                 }
  274.     
  275.                 *gptr = 0;
  276.             }
  277.  
  278.                 /* Standard data. */
  279.         
  280.             Easy.es_StructSize = sizeof( struct EasyStruct );
  281.             Easy.es_Flags = NULL;
  282.             Easy.es_Title = GetStr( MSG_WINDOWTITLE_INFO );
  283.             Easy.es_TextFormat = ( STRPTR )Text;
  284.             Easy.es_GadgetFormat = ( STRPTR )Gadgets;
  285.         
  286.             Result = EasyRequestArgs( AktuDI->Wnd, &Easy, NULL, Args);
  287.  
  288.             FreeVec( Gadgets );
  289.         }
  290.         else
  291.             Result = 0;
  292.  
  293.         return( Result );
  294.     }
  295.     else
  296.         return( rtEZRequestTags( Text, ButtonText, NULL, Args, RTEZ_ReqTitle, GetStr( MSG_WINDOWTITLE_INFO ), AktuDI->Wnd ? RT_Window : TAG_IGNORE, AktuDI->Wnd, RT_Underscore, '_', TAG_DONE ));
  297. }
  298.  
  299. void DisplayLocaleText( char *Text )
  300. {
  301.     MyMainFullRequest( GetStr( Text ), GetStr( MSG_GADGET_CONTINUE ), 0 );
  302. }
  303.  
  304. ULONG MyRequest( char *Text, ULONG Data )
  305. {
  306.     return( MyMainFullRequest( GetStr( Text ), GetStr( MSG_GADGET_CONTINUE ), &Data ));
  307. }
  308.  
  309. ULONG MyRequestNoLocale( char *Text, ULONG Data )
  310. {
  311.     return( MyMainFullRequest( Text, GetStr( MSG_GADGET_CONTINUE ), &Data ));
  312. }
  313.  
  314. /* 
  315.  * MyFullRequest( char *Text, char *ButtonText, ... )
  316.  *
  317.  * Öffnet einen Requester bestimmbarem Text und Gadgets und einer
  318.  * beliebigen Anzahl von Argumenten
  319.  */
  320.  
  321. ULONG __stdargs MyFullRequestNoLocale( char *Text, char *ButtonText, ... )
  322. {
  323.     ULONG Result;
  324.     va_list VarArgs;
  325.  
  326.     va_start( VarArgs, ButtonText );
  327.     Result = MyMainFullRequest( Text, ButtonText, VarArgs );
  328.     va_end( VarArgs );
  329.  
  330.     return( Result );
  331. }
  332.  
  333. ULONG __stdargs MyFullRequest( char *Text, char *ButtonText, ... )
  334. {
  335.     ULONG Result;
  336.     va_list VarArgs;
  337.  
  338.     va_start( VarArgs, ButtonText );
  339.     Result = MyMainFullRequest( GetStr( Text ), GetStr( ButtonText ), VarArgs );
  340.     va_end( VarArgs );
  341.  
  342.     return( Result );
  343. }
  344.  
  345. /*
  346.  * char *GetStr(char *idstr)
  347.  * 
  348.  * Ermittelt, wenn möglich, einen übersetzten String aus dem ID-String.
  349.  */
  350.  
  351. char *GetStr(char *idstr)
  352. {
  353.     char *local;
  354.  
  355.     local = idstr + 2;
  356.     if(LocaleBase)
  357.         return((char *)GetCatalogStr(Catalog, *(UWORD *)idstr, local));
  358.     else
  359.         return(local);
  360. }
  361.  
  362. enum {
  363.     GD_JUMPTO_NUMBER,
  364.     GD_JUMPTO_OK,
  365.     GD_JUMPTO_CANCEL
  366. };
  367.  
  368. static struct MyNewGadget JumptoNewGadgets[] =
  369. {
  370.     HEX_KIND, 0, 0, 0, MSG_GADGET_JUMPTO_NUMBER, 0, 8, 0, 9, 0,
  371.  
  372.     BUTTON_KIND, GP_LEFTBOTTOM, 0, 0, MSG_GADGET_OK, 0, 0, 0, 0, 0,
  373.     BUTTON_KIND, GP_RIGHTBOTTOM, 0, 0, MSG_GADGET_CANCEL, 0, 0, 0, 0, 0,
  374.     0
  375. };
  376.  
  377. static struct WindowData JumptoWD =
  378. {
  379.     NULL,    NULL,    FALSE, NULL, NULL,
  380.     0,0,
  381.     &JumptoNewGadgets[ 0 ], 3
  382. };
  383.  
  384. void JumpToByte(void)
  385. {
  386.     static long wert = 0;
  387.     long err;
  388.     UBYTE NumberString[9];
  389.  
  390.     JumptoNewGadgets[ GD_JUMPTO_NUMBER ].CurrentValue = ( LONG ) NumberString;
  391.     sprintf( NumberString, "%lx", wert );
  392.  
  393.     if( err = NewOpenAWindow( &JumptoWD, GetStr(MSG_WINDOWTITLE_JUMPTOBYTE)))
  394.         MyRequest( MSG_INFO_GLOBAL_CANTOPENWINDOW, err );
  395.     else
  396.     {
  397.         int EndeFlag = FALSE;
  398.         ULONG signals;
  399.         struct IntuiMessage    *m, Msg;
  400.         struct Gadget *gad;
  401.     
  402.         BOOL wie = FALSE;        /* Wie wurde Window verlassen ? */
  403.  
  404.         ActivateGadget( JumptoWD.Gadgets[ GD_JUMPTO_NUMBER ], JumptoWD.Wnd, 0);
  405.     
  406.         while(EndeFlag==FALSE)
  407.         {
  408.             signals=Wait(1 << JumptoWD.Wnd->UserPort->mp_SigBit);
  409.     
  410.             if(signals&(1 << JumptoWD.Wnd->UserPort->mp_SigBit))
  411.                 while(m = GT_GetIMsg( JumptoWD.Wnd->UserPort))
  412.                 {
  413.                     CopyMem((char *)m, (char *)&Msg, (long)sizeof(struct IntuiMessage));
  414.     
  415.                     GT_ReplyIMsg(m);
  416.     
  417.                     KeySelect(JumptoWD.Gadgets, &Msg);
  418.     
  419.                     gad = (struct Gadget *) Msg.IAddress;
  420.     
  421.                     switch( Msg.Class )
  422.                     {
  423.                         case    IDCMP_REFRESHWINDOW:
  424.                             GT_BeginRefresh( JumptoWD.Wnd );
  425.                             GT_EndRefresh( JumptoWD.Wnd, TRUE );
  426.                             break;
  427.     
  428.                         case    IDCMP_VANILLAKEY:
  429.                             if( Msg.Code == 13)
  430.                             {
  431.                                 EndeFlag = TRUE;
  432.                                 wie = TRUE;
  433.                             }
  434.                             break;
  435.     
  436.                         case    IDCMP_CLOSEWINDOW:
  437.                             EndeFlag = TRUE;
  438.                             break;
  439.     
  440.                         case IDCMP_MOUSEMOVE:
  441.                             ((struct MyNewGadget *)gad->UserData)->CurrentValue = Msg.Code;
  442.                             break;
  443.     
  444.                         case    IDCMP_GADGETUP:
  445.                             switch(gad->GadgetID)
  446.                             {
  447.                                 case GD_JUMPTO_NUMBER:
  448.                                 case GD_JUMPTO_OK:
  449.                                     if( !IsHexString( GetString(JumptoWD.Gadgets[GD_JUMPTO_NUMBER])))
  450.                                     {
  451.                                         MyRequest( MSG_INFO_GLOBAL_ILLEGALCHARACTERS, ( ULONG )GetString(JumptoWD.Gadgets[GD_JUMPTO_NUMBER]));
  452.                                         ActivateGadget(JumptoWD.Gadgets[GD_JUMPTO_NUMBER],JumptoWD.Wnd,0);
  453.                                     }
  454.                                     else
  455.                                     {    
  456.                                         wie = TRUE;
  457.                                         EndeFlag = TRUE;
  458.                                     }
  459.                                     break;
  460.                                 case GD_JUMPTO_CANCEL:
  461.                                     EndeFlag = TRUE;
  462.                                     break;
  463.                             }
  464.                             break;
  465.                     }
  466.                 }
  467.         }
  468.  
  469.         if( wie )
  470.             if( IsHexString( GetString(JumptoWD.Gadgets[GD_JUMPTO_NUMBER])))
  471.                 stch_l( GetString( JumptoWD.Gadgets[ GD_JUMPTO_NUMBER ]), &wert);
  472.  
  473.         NewCloseAWindow( &JumptoWD );
  474.  
  475.         if( wie )
  476.         {
  477.             if( AktuDD->FD->Typ == FD_GRAB )
  478.             {
  479.                 if( wert < ( long )AktuDD->FD->Mem )
  480.                     wert = ( long )AktuDD->FD->Mem;
  481.                 if( wert >= ( long )AktuDD->FD->Mem + AktuDD->FD->Len )
  482.                     wert = ( long )AktuDD->FD->Mem + AktuDD->FD->Len - 1;
  483.                 
  484.                 SetCursor( wert - ( long )AktuDD->FD->Mem, AktuDD );
  485.             }
  486.             else
  487.             {
  488.                 if( wert >= AktuDD->FD->Len ) wert = AktuDD->FD->Len - 1;
  489.                 SetCursor( wert, AktuDD);
  490.             }
  491.         }
  492.     }
  493. }
  494.  
  495. void MarkLocation( ULONG Number, struct DisplayData *DD )
  496. {
  497.     if( !Number )
  498.     {
  499.         if( !GetWert( &DD->FD->LocationNumber, MSG_WINDOWTITLE_LOCATIONNUMBER, 1, 10 ))
  500.             return;
  501.     }
  502.     else
  503.         DD->FD->LocationNumber = Number;
  504.  
  505.     DD->FD->Locations[ DD->FD->LocationNumber - 1 ] = DD->CPos;
  506. }
  507.  
  508. void JumpToLocation( LONG Number, struct DisplayData *DD )
  509. {
  510.     if( !Number )
  511.     {
  512.         if( !GetWert( &DD->FD->LocationNumber, MSG_WINDOWTITLE_LOCATIONNUMBER, 1, 10 ))
  513.             return;
  514.     }
  515.     else
  516.         DD->FD->LocationNumber = Number;
  517.  
  518.     SetCursor( DD->FD->Locations[ DD->FD->LocationNumber - 1 ], DD);
  519. }
  520.  
  521.  
  522. /*
  523.  * BOOL MyRequestFile(char *FullName, char *Title, char *Pattern, BOOL Buffered )
  524.  * 
  525.  * Öffnet einen Filerequester(Asl/Reqtools).
  526.  *
  527.  * ACHTUNG!: fullname wird ggf. verändert
  528.  */
  529.  
  530. BOOL MyRequestFile( char *FullName, char *Title, char *Pattern, BOOL Buffered)
  531. {
  532.     BOOL Success = FALSE;
  533.     char FileName[256], PathName[256];
  534.  
  535.     strcpy( FileName, FilePart( FullName ));
  536.     strcpy( PathName, FullName);
  537.     *PathPart( PathName ) = 0;
  538.  
  539.     if( UseAsl )
  540.     {
  541.         static char BufferedPattern[ 256 ];
  542.  
  543.         if( Buffered & ( !Pattern ))
  544.             Pattern = BufferedPattern;
  545.  
  546.         if( AslRequestTags( Asl_FileFileReq, ASLFR_Window, AktuDI->Wnd, ASLFR_InitialFile, FileName, ASLFR_InitialDrawer, PathName, ASLFR_Window, AktuDI->Wnd, ASLFR_TitleText, Title, ASLFR_InitialPattern, Pattern ? Pattern : "", TAG_DONE ))
  547.         {
  548.             strcpy( FullName, Asl_FileFileReq->rf_Dir );
  549.             AddPart( FullName, Asl_FileFileReq->rf_File, 256 );
  550.  
  551.             Success = TRUE;
  552.         }
  553.  
  554.         if( Buffered )
  555.             strcpy( BufferedPattern, Asl_FileFileReq->fr_Pattern );
  556.     }
  557.     else
  558.     {    
  559.         struct rtFileRequester *FileReq;
  560.  
  561.         if( Buffered )
  562.         {
  563.             FileReq = FileFileReq;
  564.  
  565.             if( 0 != strcmp( PathName, FileReq->Dir ))
  566.                 rtChangeReqAttr( FileReq, RTFI_Dir, PathName, TAG_DONE );
  567.         }
  568.         else
  569.             FileReq = rtAllocRequestA( RT_FILEREQ, NULL );
  570.  
  571.         if( FileReq )
  572.         {
  573.                 /* Pathnamen und ggf. Pattern setzen */
  574.  
  575.             rtChangeReqAttr( FileReq, RTFI_Dir, PathName, Pattern ? RTFI_MatchPat : TAG_IGNORE, Pattern, TAG_DONE );
  576.  
  577.             if( rtFileRequest( FileReq, FileName, Title, RTFI_Flags, FREQF_PATGAD, AktuDI->Wnd ? RT_Window : TAG_IGNORE, AktuDI->Wnd, TAG_END ))
  578.             {
  579.                 strcpy( FullName, FileReq->Dir );
  580.                 AddPart( FullName, FileName, 256 );
  581.  
  582.                 Success = TRUE;
  583.             }
  584.     
  585.             if( !Buffered )
  586.                 rtFreeRequest( FileReq );
  587.         }
  588.     }
  589.  
  590.     return( Success );
  591. }
  592.  
  593. void ExecuteARexxCommand(char *Name)
  594. {
  595.     BPTR fh;
  596.  
  597.     if(Name)
  598.     {
  599.         if(fh=Open(arexxcommandwindow,MODE_NEWFILE))
  600.             SendRexxCommand(MyRexxHost,Name,fh);
  601.     }
  602.     else
  603.     {
  604.         UBYTE fullname[256] = "Rexx:";
  605.  
  606.         if( MyRequestFile( fullname, GetStr( MSG_WINDOWTITLE_SELECTCOMMAND ), "#?.filex", FALSE ))
  607.         {
  608.             if(fh=Open(arexxcommandwindow,MODE_NEWFILE))
  609.                 SendRexxCommand(MyRexxHost,fullname,fh);
  610.         }
  611.     }
  612. }
  613.  
  614. void ExecuteARexxCommandNumber(LONG Number)
  615. {
  616.     if((Number>=0)&&(Number<=9))
  617.     {
  618.         if(arexxcommandused[Number] == TRUE)
  619.         {
  620.             ExecuteARexxCommand(arexxcommands[Number]);
  621.         }
  622.     }
  623. }
  624.  
  625. BOOL StringToMem(char *string,UBYTE *mem,long laenge)
  626. {
  627.     BOOL Success=TRUE;
  628.     UBYTE *ptr=mem;
  629.     UBYTE wert;
  630.  
  631.     while((ptr<mem+laenge) && Success)
  632.     {
  633.         while(*string && ((*string==' ') || (*string=='\t')))string++;
  634.  
  635.         if(*string && isxdigit(*string) && isxdigit(*(string+1)))
  636.         {
  637.             if(isdigit(*string))
  638.                 wert=(*string-'0') * 0x10;
  639.             else
  640.                 wert=(tolower(*string)-'a'+10)*0x10;
  641.  
  642.             string++;
  643.  
  644.             if(*string)
  645.             {
  646.                 if(isdigit(*string))
  647.                     wert+=*string-'0';
  648.                 else
  649.                     wert+=tolower(*string)-'a'+10;
  650.  
  651.                 string++;
  652.                 *ptr++=wert;
  653.             }
  654.             else
  655.                 Success=FALSE;
  656.         }
  657.         else
  658.             Success=FALSE;
  659.     }
  660.  
  661.     return(Success);
  662. }
  663.  
  664.  
  665.  
  666. /*********************************************************************
  667.  *        Clipboardsupportroutinen                                                    *
  668.  *                                                                                            *
  669.  *                                                                                            *
  670.  *********************************************************************/
  671.  
  672. #include <libraries/iffparse.h>
  673. #include <clib/iffparse_protos.h>
  674.  
  675. #define ID_FTXT    MAKE_ID('F','T','X','T')    /* Formatted text. */
  676. #define ID_CHRS    MAKE_ID('C','H','R','S')    /* Character data. */
  677.  
  678. static LONG clipboardunit;
  679.  
  680.     /* SaveClip(STRPTR Buffer,LONG Size):
  681.      *
  682.      *    Send a given text buffer to the clipboard.
  683.      */
  684.  
  685. BOOL SaveClip(STRPTR Buffer,LONG Size)
  686. {
  687.     BYTE Success = FALSE;
  688.  
  689.     if(Size > 0)
  690.     {
  691.         struct IFFHandle *Handle;
  692.  
  693.         if(Handle = AllocIFF())
  694.         {
  695.             if(Handle -> iff_Stream = (ULONG)OpenClipboard(clipboardunit))
  696.             {
  697.                 InitIFFasClip(Handle);
  698.  
  699.                 if(!OpenIFF(Handle,IFFF_WRITE))
  700.                 {
  701.                     if(!PushChunk(Handle,ID_FTXT,ID_FORM,IFFSIZE_UNKNOWN))
  702.                     {
  703.                         if(!PushChunk(Handle,0,ID_CHRS,IFFSIZE_UNKNOWN))
  704.                         {
  705.                             if(WriteChunkBytes(Handle,Buffer,Size) == Size)
  706.                             {
  707.                                 if(!PopChunk(Handle))
  708.                                     Success = TRUE;
  709.                             }
  710.                         }
  711.                     }
  712.  
  713.                     if(Success)
  714.                     {
  715.                         if(PopChunk(Handle))
  716.                             Success = FALSE;
  717.                     }
  718.  
  719.                     CloseIFF(Handle);
  720.                 }
  721.  
  722.                 CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  723.             }
  724.  
  725.             FreeIFF(Handle);
  726.         }
  727.     }
  728.  
  729.     return(Success);
  730. }
  731.  
  732. UBYTE *GetClip( ULONG *laenge )
  733. {
  734.     struct IFFHandle    *Handle;
  735.     UBYTE *mem = 0;
  736.  
  737.     *laenge = 0;
  738.  
  739.     if(Handle = AllocIFF())
  740.     {
  741.         if(Handle -> iff_Stream = (ULONG)OpenClipboard(clipboardunit))
  742.         {
  743.             InitIFFasClip(Handle);
  744.  
  745.             if(!OpenIFF(Handle,IFFF_READ))
  746.             {
  747.                 if(!StopChunk(Handle,ID_FTXT,ID_CHRS))
  748.                 {
  749.                     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  750.                     {
  751.                         struct ContextNode *ContextNode = CurrentChunk(Handle);
  752.  
  753.                         if(ContextNode -> cn_Type == ID_FTXT)
  754.                         {
  755.                             *laenge = ContextNode -> cn_Size;
  756.  
  757.                             if(*laenge)
  758.                             if(mem = AllocMem(*laenge,MEMF_ANY))
  759.                             {
  760.                                 ReadChunkRecords(Handle,mem,*laenge,1);
  761.                             }
  762.                         }
  763.                     }
  764.                 }
  765.  
  766.                 CloseIFF(Handle);
  767.             }
  768.  
  769.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  770.         }
  771.  
  772.         FreeIFF(Handle);
  773.     }
  774.  
  775.     return( mem );
  776. }
  777.  
  778. BOOL SetClipboardUnit(LONG new)
  779. {
  780.     if((new>=0)&&(new<=256)){clipboardunit=new;return(TRUE);}
  781.     return(FALSE);
  782. }
  783.  
  784. LONG GetClipboardUnit( void )
  785. {
  786.     return( clipboardunit );
  787. }
  788.